((typeof self !== 'undefined' ? self : this)["webpackJsonpproduct_manager"] = (typeof self !== 'undefined' ? self : this)["webpackJsonpproduct_manager"] || []).push([[21],{

/***/ "0538":
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var aFunction = __webpack_require__("1c0b");
var isObject = __webpack_require__("861d");

var slice = [].slice;
var factories = {};

var construct = function (C, argsLength, args) {
  if (!(argsLength in factories)) {
    for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';
    // eslint-disable-next-line no-new-func -- we have no proper alternatives, IE8- only
    factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')');
  } return factories[argsLength](C, args);
};

// `Function.prototype.bind` method implementation
// https://tc39.es/ecma262/#sec-function.prototype.bind
module.exports = Function.bind || function bind(that /* , ...args */) {
  var fn = aFunction(this);
  var partArgs = slice.call(arguments, 1);
  var boundFunction = function bound(/* args... */) {
    var args = partArgs.concat(slice.call(arguments));
    return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args);
  };
  if (isObject(fn.prototype)) boundFunction.prototype = fn.prototype;
  return boundFunction;
};


/***/ }),

/***/ "131a":
/***/ (function(module, exports, __webpack_require__) {

var $ = __webpack_require__("23e7");
var setPrototypeOf = __webpack_require__("d2bb");

// `Object.setPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.setprototypeof
$({ target: 'Object', stat: true }, {
  setPrototypeOf: setPrototypeOf
});


/***/ }),

/***/ "257e":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

/***/ }),

/***/ "262e":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXPORTS
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _inherits; });

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.set-prototype-of.js
var es_object_set_prototype_of = __webpack_require__("131a");

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

/***/ }),

/***/ "2caf":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXPORTS
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _createSuper; });

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.reflect.construct.js
var es_reflect_construct = __webpack_require__("4ae1");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.set-prototype-of.js
var es_object_set_prototype_of = __webpack_require__("131a");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.get-prototype-of.js
var es_object_get_prototype_of = __webpack_require__("3410");

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js


function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
var possibleConstructorReturn = __webpack_require__("99de");

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js




function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();
  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived),
        result;

    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor;
      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return Object(possibleConstructorReturn["a" /* default */])(this, result);
  };
}

/***/ }),

/***/ "3410":
/***/ (function(module, exports, __webpack_require__) {

var $ = __webpack_require__("23e7");
var fails = __webpack_require__("d039");
var toObject = __webpack_require__("7b0b");
var nativeGetPrototypeOf = __webpack_require__("e163");
var CORRECT_PROTOTYPE_GETTER = __webpack_require__("e177");

var FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); });

// `Object.getPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.getprototypeof
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, {
  getPrototypeOf: function getPrototypeOf(it) {
    return nativeGetPrototypeOf(toObject(it));
  }
});



/***/ }),

/***/ "4ae1":
/***/ (function(module, exports, __webpack_require__) {

var $ = __webpack_require__("23e7");
var getBuiltIn = __webpack_require__("d066");
var aFunction = __webpack_require__("1c0b");
var anObject = __webpack_require__("825a");
var isObject = __webpack_require__("861d");
var create = __webpack_require__("7c73");
var bind = __webpack_require__("0538");
var fails = __webpack_require__("d039");

var nativeConstruct = getBuiltIn('Reflect', 'construct');

// `Reflect.construct` method
// https://tc39.es/ecma262/#sec-reflect.construct
// MS Edge supports only 2 arguments and argumentsList argument is optional
// FF Nightly sets third argument as `new.target`, but does not create `this` from it
var NEW_TARGET_BUG = fails(function () {
  function F() { /* empty */ }
  return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F);
});
var ARGS_BUG = !fails(function () {
  nativeConstruct(function () { /* empty */ });
});
var FORCED = NEW_TARGET_BUG || ARGS_BUG;

$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, {
  construct: function construct(Target, args /* , newTarget */) {
    aFunction(Target);
    anObject(args);
    var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
    if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);
    if (Target == newTarget) {
      // w/o altered newTarget, optimization for 0-4 arguments
      switch (args.length) {
        case 0: return new Target();
        case 1: return new Target(args[0]);
        case 2: return new Target(args[0], args[1]);
        case 3: return new Target(args[0], args[1], args[2]);
        case 4: return new Target(args[0], args[1], args[2], args[3]);
      }
      // w/o altered newTarget, lot of arguments case
      var $args = [null];
      $args.push.apply($args, args);
      return new (bind.apply(Target, $args))();
    }
    // with altered newTarget, not support built-in constructors
    var proto = newTarget.prototype;
    var instance = create(isObject(proto) ? proto : Object.prototype);
    var result = Function.apply.call(Target, instance, args);
    return isObject(result) ? result : instance;
  }
});


/***/ }),

/***/ "7037":
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__("a4d3");

__webpack_require__("e01a");

__webpack_require__("d3b7");

__webpack_require__("d28b");

__webpack_require__("e260");

__webpack_require__("3ca3");

__webpack_require__("ddb0");

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    module.exports = _typeof = function _typeof(obj) {
      return typeof obj;
    };

    module.exports["default"] = module.exports, module.exports.__esModule = true;
  } else {
    module.exports = _typeof = function _typeof(obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    module.exports["default"] = module.exports, module.exports.__esModule = true;
  }

  return _typeof(obj);
}

module.exports = _typeof;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),

/***/ "99de":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("7037");
/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("257e");


function _possibleConstructorReturn(self, call) {
  if (call && (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(call) === "object" || typeof call === "function")) {
    return call;
  }

  return Object(_assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
}

/***/ }),

/***/ "a282":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, "CreateLoader", function() { return /* reexport */ create_loader_CreateLoader; });
__webpack_require__.d(__webpack_exports__, "CreateRegister", function() { return /* reexport */ create_register_CreateRegister; });
__webpack_require__.d(__webpack_exports__, "CreateLoaderMixin", function() { return /* reexport */ create_loader_mixin_CreateLoaderMixin; });

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
var classCallCheck = __webpack_require__("d4ec");

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
var createClass = __webpack_require__("bee2");

// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom-collections.for-each.js
var web_dom_collections_for_each = __webpack_require__("159b");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.keys.js
var es_object_keys = __webpack_require__("b64b");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.to-string.js
var es_object_to_string = __webpack_require__("d3b7");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.js
var es_promise = __webpack_require__("e6cf");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.iterator.js
var es_array_iterator = __webpack_require__("e260");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.iterator.js
var es_string_iterator = __webpack_require__("3ca3");

// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom-collections.iterator.js
var web_dom_collections_iterator = __webpack_require__("ddb0");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.map.js
var es_array_map = __webpack_require__("d81d");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.concat.js
var es_array_concat = __webpack_require__("99af");

// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/helper.js



function getType(v) {
  return Object.prototype.toString.call(v);
}

function isArray(a) {
  return getType(a) === "[object Array]";
}
function isObject(o) {
  return getType(o) === "[object Object]";
}
function isFunction(func) {
  return getType(func) === "[object Function]";
}
function addTimestamp(url) {
  return url.indexOf("?") > -1 ? "".concat(url, "&t=").concat(Date.now()) : "".concat(url, "?t=").concat(Date.now());
}
function noop() {}
// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/constant.js
var DEFAULT_SHARED_POOL_NAME = "microApp";
// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/create-loader.js












/**
 * module loader
 *
 * @export
 * @class createLoader
 */

var create_loader_CreateLoader = /*#__PURE__*/function () {
  function CreateLoader() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    Object(classCallCheck["a" /* default */])(this, CreateLoader);

    if (!isObject(options)) {
      throw new TypeError("Illegal parameter: options, expect an object.");
    }

    var _global = options.global || window;

    var _poolName = options.poolName || DEFAULT_SHARED_POOL_NAME;

    _global['poolName'] = _poolName;
    this.pool = _global[_poolName] = {}; // shared pool

    this.noCache = typeof options.cache === "undefined" ? true : !!options.cache;
    this.mountStore(options.store);
    this.mountRouter(options.router);
    this.mountApp(options.app ? options.app : this.$root);
    this.mountZhLang(options.zhLang ? options.zhLang : {});
    this.mountEnLang(options.enLang ? options.enLang : {});
  }

  Object(createClass["a" /* default */])(CreateLoader, [{
    key: "mountZhLang",
    value: function mountZhLang(zhLang) {
      if (isObject(zhLang)) {
        this.pool['zhI18n'] = zhLang;
      }
    }
  }, {
    key: "mountEnLang",
    value: function mountEnLang(enLang) {
      if (isObject(enLang)) {
        this.pool['enI18n'] = enLang;
      }
    }
    /**
     * mount vue instance
     *
     * @param {*} app
     * @memberof createLoader
     */

  }, {
    key: "mountApp",
    value: function mountApp(app) {
      if (isObject(app)) {
        this.pool.app = app;
      }
    }
    /**
     * mount vue-router instance
     *
     * @param {*} router
     * @memberof createLoader
     */

  }, {
    key: "mountRouter",
    value: function mountRouter(router) {
      if (isObject(router)) {
        this.pool.router = router;
      }
    }
    /**
     * mount vuex instance
     *
     * @param {*} store
     * @memberof createLoader
     */

  }, {
    key: "mountStore",
    value: function mountStore(store) {
      if (isObject(store)) {
        this.pool.store = store;
      }
    }
    /**
     * remove global pool
     *
     * @memberof createLoader
     */

  }, {
    key: "remove",
    value: function remove() {
      var pool = this.pool;
      Object.keys(pool).forEach(function (v) {
        delete pool[v];
      });
    }
    /**
     * load module
     *
     * @param {*} url
     * @returns {Promise}
     * @memberof createLoader
     *
     * @example
     * loadModule('/path/to/module.js').then((res) => { console.log(res) })
     */

  }, {
    key: "loadModule",
    value: function loadModule(url) {
      var _this = this;

      if (!url || typeof url !== "string") {
        return Promise.reject("Illegal parameter: url, expect a not empty string.");
      }

      return new Promise(function (resolve) {
        var script = document.createElement("script");
        script.type = "text/javascript";
        script.async = true;

        script.onload = function (_ref) {
          var type = _ref.type;
          return resolve({
            type: type,
            url: url
          });
        };

        script.onerror = function (_ref2) {
          var type = _ref2.type;
          return resolve({
            type: type,
            url: url
          });
        };

        script.src = _this.noCache ? addTimestamp(url) : url;
        document.body.appendChild(script);
      });
    }
    /**
     * load modules
     *
     * @param {*} [urls=[]]
     * @returns {Promise}
     * @memberof createLoader
     *
     * @example
     * loadModules(['/path/to/module-1.js', '/path/to/module-2.js']).then((res) => { console.log(res) })
     */

  }, {
    key: "loadModules",
    value: function loadModules() {
      var _this2 = this;

      var urls = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

      if (!isArray(urls)) {
        return Promise.reject("Illegal parameter: urls, expect an array.");
      }

      return Promise.all(urls.map(function (v) {
        return _this2.loadModule(v);
      })).then(function (res) {
        // this.remove();
        return res;
      });
    }
  }]);

  return CreateLoader;
}();


// EXTERNAL MODULE: ./node_modules/core-js/modules/es.function.name.js
var es_function_name = __webpack_require__("b0c0");

// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/create-register.js





/**
 * module register
 *
 * @export
 * @class createRegister
 */

var create_register_CreateRegister = /*#__PURE__*/function () {
  function CreateRegister() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    Object(classCallCheck["a" /* default */])(this, CreateRegister);

    if (!isObject(options)) {
      throw new TypeError("Illegal parameter: options, expect an object.");
    }

    if (!options.name) {
      throw new TypeError("Illegal parameter: options, expect has a 'name' field.");
    }

    var _global = options.global || window;

    var _poolName = options.poolName || DEFAULT_SHARED_POOL_NAME;

    this.pool = _global[_poolName] || {}; // shared pool

    this.hasLog = typeof options.log === "undefined" ? true : !!options.log;
    this.moduleName = options.name;
  }
  /**
   * assign i18n
   *
   * @returns {createRegister}
   * @memberof createRegister
   */


  Object(createClass["a" /* default */])(CreateRegister, [{
    key: "addLang",
    value: function addLang(zhlang, enLang) {
      var zhLangPortal = this.pool['zhI18n'];
      var enLangPortal = this.pool['enI18n'];

      if (isObject(zhLangPortal) && isObject(enLangPortal)) {
        if (typeof this.moduleName !== 'string') {
          throw new Error('lack name of module or incorrect format, because langs needs name of string when merge');
        } else {
          if (isObject(zhlang)) {
            zhLangPortal[this.moduleName] = zhlang;
          }

          if (isObject(enLang)) {
            enLangPortal[this.moduleName] = enLang;
          }

          this.log("register lang");
        }
      }

      return this;
    }
    /**
     * register vue-router
     *
     * @returns {createRegister}
     * @memberof createRegister
     */

  }, {
    key: "addRoutes",
    value: function addRoutes(routes) {
      var routerInstance = this.pool.router;

      if (isObject(routerInstance) && isFunction(routerInstance.addRoutes) && isArray(routes)) {
        routerInstance.addRoutes(routes);
        this.log("register routes");
      }

      return this;
    }
    /**
     * register vuex module
     *
     * @returns {createRegister}
     * @memberof createRegister
     */

  }, {
    key: "registerModule",
    value: function registerModule(store) {
      var storeInstance = this.pool.store;

      if (isObject(storeInstance) && isFunction(storeInstance.registerModule) && isObject(store)) {
        storeInstance.registerModule(this.moduleName, store);
        this.log("register store");
      }

      return this;
    }
  }, {
    key: "log",
    value: function log(msg) {
      // eslint-disable-next-line no-console
      this.hasLog && console.log("[".concat(this.moduleName, "]:"), msg);
    }
  }]);

  return CreateRegister;
}();


// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
var possibleConstructorReturn = __webpack_require__("99de");

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
var assertThisInitialized = __webpack_require__("257e");

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules
var inherits = __webpack_require__("262e");

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 2 modules
var createSuper = __webpack_require__("2caf");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.find.js
var es_array_find = __webpack_require__("7db0");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.exec.js
var es_regexp_exec = __webpack_require__("ac1f");

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.split.js
var es_string_split = __webpack_require__("1276");

// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/create-loader-mixin.js












var create_loader_mixin_CreateLoaderMixin = /*#__PURE__*/function (_CreateLoader) {
  Object(inherits["a" /* default */])(CreateLoaderMixin, _CreateLoader);

  var _super = Object(createSuper["a" /* default */])(CreateLoaderMixin);

  function CreateLoaderMixin() {
    var _this;

    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    Object(classCallCheck["a" /* default */])(this, CreateLoaderMixin);

    if (!isObject(options)) {
      throw new TypeError("Illegal parameter: options, expect an object.");
    }

    _this = _super.call(this, options);

    var loadModule = _this.loadModule.bind(Object(assertThisInitialized["a" /* default */])(_this));

    var modules = options.modules,
        _options$beforeLoad = options.beforeLoad,
        beforeLoad = _options$beforeLoad === void 0 ? noop : _options$beforeLoad,
        _options$afterLoad = options.afterLoad,
        afterLoad = _options$afterLoad === void 0 ? noop : _options$afterLoad,
        _options$onError = options.onError,
        onError = _options$onError === void 0 ? noop : _options$onError,
        _options$onNotFound = options.onNotFound,
        onNotFound = _options$onNotFound === void 0 ? noop : _options$onNotFound;

    if (!isArray(modules) || modules.some(function (_ref) {
      var name = _ref.name,
          url = _ref.url;
      return !name || !url;
    })) {
      throw new TypeError("Illegal parameter: options.modules, expect an object array (Array<{name: string, url: string}>).");
    }

    return Object(possibleConstructorReturn["a" /* default */])(_this, {
      methods: {
        // asynchronous loading module
        $_handleRouteChange: function $_handleRouteChange(path) {
          if (path === '/') return;
          var module = modules.find(function (m) {
            var paths = path.split('/');

            if (paths[1] === 'items' && paths[2] === m.name) {
              return true;
            }
          });

          if (!module) {
            if (isFunction(onNotFound)) {
              onNotFound();
            }
          }

          if (module && (!module.status || module.status === 'error')) {
            module.status = "pending"; // before load callback

            if (isFunction(beforeLoad)) {
              beforeLoad(module);
            }

            loadModule(module.url).then(function (_ref2) {
              var type = _ref2.type;

              if (type === "load") {
                module.status = "load"; // after load callback

                if (isFunction(afterLoad)) {
                  afterLoad(module);
                }
              } else {
                module.status = "error"; // load error callback

                if (isFunction(onError)) {
                  onError(module);
                }
              }
            });
          }
        }
      },
      created: function created() {
        var _this2 = this;

        if (!this.$root.$_VUE_MODULE_REGISTER) {
          this.$root.$_VUE_MODULE_REGISTER = true;
          this.$_VUE_MODULE_REGISTER_unwatchFn = this.$watch("$route", function (_ref3) {
            var path = _ref3.path;

            _this2.$_handleRouteChange(path);
          }, {
            immediate: true
          });
        }
      },
      beforeDestroy: function beforeDestroy() {
        if (this.$_VUE_MODULE_REGISTER_unwatchFn instanceof Function) {
          this.$_VUE_MODULE_REGISTER_unwatchFn();
        }
      }
    });
  }

  return CreateLoaderMixin;
}(create_loader_CreateLoader);


// CONCATENATED MODULE: ./node_modules/micro-frontends-server/src/index.js





/***/ }),

/***/ "bee2":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

/***/ }),

/***/ "d4ec":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

/***/ })

}]);